home *** CD-ROM | disk | FTP | other *** search
/ NetNews Offline 2 / NetNews Offline Volume 2.iso / news / comp / lang / c++-part2 / 18379 < prev    next >
Encoding:
Text File  |  1996-08-05  |  2.7 KB  |  103 lines
  1. Path: ix.netcom.com!news
  2. From: miker3@ix.netcom.com (Mike Rubenstein)
  3. Newsgroups: comp.lang.c++
  4. Subject: Re: String operator+ and memory leakage.
  5. Date: Fri, 19 Apr 1996 16:02:18 GMT
  6. Organization: Netcom
  7. Message-ID: <3177b7d5.149465039@nntp.ix.netcom.com>
  8. References: <4l5foo$fen@utopia.hacktic.nl>
  9. NNTP-Posting-Host: ix-dc14-19.ix.netcom.com
  10. X-NETCOM-Date: Fri Apr 19 11:05:51 AM CDT 1996
  11. X-Newsreader: Forte Agent .99d/32.182
  12.  
  13. Mike Tavares <MIKET@cdynamics.com> wrote:
  14.  
  15. > I have an implementation (not mine) of the String class that is leaking 
  16. > memory
  17. > during the + operator code.  The code follows:
  18. > 
  19. > class String
  20. >     {
  21. >     public:
  22. > 
  23. >         // Constructors/destructors
  24. >         String();
  25. >         String( char* new_string);
  26. >         String( String& new_string);
  27. > 
  28. >         ~String()
  29. >             {
  30. >             delete character_array;
  31. >             }
  32. > 
  33. >         String&     operator+( String& a_string );
  34. >         String&     operator=( String& a_string );
  35. >         operator    char* () { return character_array; }
  36. > 
  37. >     private:
  38. > 
  39. >         char* character_array;
  40. >         int string_length;
  41. >     };
  42. > 
  43. > String&
  44. > String::operator+( String& a_string )
  45. >     {
  46. >     int total_size = string_length + strlen( a_string ) + 1;
  47. >     char* temp_array = new char[total_size];
  48. >     char* char_array = a_string;
  49. > 
  50. >     strcpy( temp_array, character_array );
  51. >     strcat( temp_array, char_array );
  52. > 
  53. >     String* new_string = new String( temp_array );
  54. >     delete [] temp_array;
  55. >     return *new_string;
  56. >     }
  57. > 
  58. > String&
  59. > String::operator=( String& a_string )
  60. >     {
  61. >     char* new_char_array = a_string;
  62. >     delete [] character_array;
  63. >     character_array = new char[strlen( new_char_array ) + 1];
  64. >     strcpy( character_array, new_char_array );
  65. >     string_length = strlen( character_array );
  66. >     return *this;
  67. >     }
  68. > 
  69. > My usage is:
  70. > 
  71. > destString = string1 + string2 + string3...;
  72. > 
  73. > 
  74. > The problem is, when new_string is created and returned through a 
  75. > reference, no one ever deletes it.
  76. > 
  77. > If I change new_string to be an automatic variable I get an error from 
  78. > the compiler about trying to pass a reference to a item that is out of 
  79. > scope.
  80. > 
  81. > If I change the method to work in this I mutate one of my addends.  There 
  82. > has to be a way of implementing this without memory leakage! HELP!
  83.  
  84. Don't return a reference.  Something like
  85.  
  86.     String&
  87.     String::operator+( String& a_string )
  88.         {
  89.           int total_size = string_length + strlen( a_string ) + 1;
  90.           char* temp_array = new char[total_size];
  91.       char* char_array = a_string;
  92.  
  93.       strcpy( temp_array, character_array );
  94.       strcat( temp_array, char_array );
  95.  
  96.       String new_string(temp_array);
  97.       delete [] temp_array;
  98.       return new_string;
  99.     }
  100.  
  101.  
  102. Michael M Rubenstein
  103.